What's this all about?

This PR implements an improved version of the generics binding improvement from #4155, with the cleaner name Generic instead of ImplParam.

Problem

When implementing generic WinRT interfaces like IMap_Impl<K, V> or IVector_Impl<T>, users had to write Ref<K> for all generic type parameters — even primitives where Ref adds no semantic value:

// Before
impl IMap_Impl<i32, f32> for Map_Impl {
    fn HasKey(&self, key: Ref<i32>) -> Result<bool> { ... }   // unnecessary Ref for i32
    fn Insert(&self, key: Ref<i32>, value: Ref<f32>) -> Result<bool> { ... }
}

The same issue affected event handler closures: TypedEventHandler::new(move |_, args: Ref<i32>| { assert_eq!(*args, 2); }).

Solution

Added a Generic<'a> generic associated type (GAT) to the Type trait in windows-core:

• For CopyType (primitives, GUID, enums, etc.): Generic<'a> = T — the type itself, no Ref wrapper
• For CloneType (HSTRING, etc.): Generic<'a> = Ref<'a, T> — same as before
• For InterfaceType (COM interfaces): Generic<'a> = Ref<'a, T> — same as before

The GAT is named Generic<'a> to avoid confusion with the existing Param trait.

A public type alias is exported:

pub type Generic<'a, T> = <T as Type<T>>::Generic<'a>;

A #[doc(hidden)] free function generic_as_default is exported from windows_core to convert a Generic<'_, T> reference to a &T::Default reference. This is needed by generic collection implementations (IMap_Impl, IVector_Impl, etc.) because Generic<'_, T> is either T itself (for CopyType) or Ref<'_, T> (for other types), and there is no built-in Rust construct that dereferences uniformly across both forms. The function is a zero-cost reinterpretation since Generic<'_, T> and T::Default always share the same memory layout. Generated vtable code uses core::mem::transmute_copy directly instead of a trait helper method.

Result

Users can now write generic type parameters directly for primitives:

// After
impl IMap_Impl<i32, f32> for Map_Impl {
    fn HasKey(&self, key: i32) -> Result<bool> { ... }        // i32 directly!
    fn Insert(&self, key: i32, value: f32) -> Result<bool> { ... }
}

// Event handler closures:
TypedEventHandler::new(move |_, args: i32| { assert_eq!(args, 2); Ok(()) })

For non-primitive types like HSTRING and COM interfaces, Generic<'_, T> resolves to Ref<'_, T> as before.

Changes

• crates/libs/core/src/type.rs — Added Generic<'a> GAT, pub type Generic<'a, T>, and a standalone generic_as_default free function; removed abi_to_generic and generic_as_default trait methods from Type
• crates/libs/bindgen/src/types/method.rs — Updated code generator to emit Generic<'_, T> in _Impl signatures and use core::mem::transmute_copy in vtable upcall code
• Regenerated collections/bindings.rs, future/bindings.rs, Foundation/mod.rs, class_dep.rs, interface_iterable.rs, delegate_generic.rs, reference_custom/bindings.rs, reference_no_deps/bindings.rs
• Updated hand-written collection implementations (map.rs, vector.rs, etc.) to use Generic<'_, T> and the generic_as_default free function
• Updated tests to use primitive types directly and removed TODO comments